49 research outputs found
TOTAM: Scoped Tuples for the Ambient
Coordination of mobile applications posses a number of issues.
Devices should be able to communicate with each other without being connected with each other at the same time while maintaining privacy and limited network traffic. Current tuple based approaches solve these issues partially but none of them solves all of them. We propose a novel tuple space-based approach where tuple spaces are annotated with tuple space descriptors used to determine the scope of a tuple. The novelty of our approach lies in the use of these tuple space descriptors to determine that a tuple should be propagated before it is transmitted. This enhances privacy and decreases the burden on the network traffic in a wide range of applications
CScript : a distributed programming language for building mixed-consistency applications
Current programming models only provide abstractions for sharing data under a homogeneous consistency model. It is, however, not uncommon for a distributed application to provide strong consistency for one part of the shared data and eventual consistency for another part. Because mixing consistency models is not supported by current programming models, writing such applications is extremely difficult. In this paper we propose CScript, a distributed object-oriented programming language with built-in support for data replication. At its core are consistent and available replicated objects. CScript regulates the interactions between these objects to avoid subtle inconsistencies that arise when mixing consistency models. Our evaluation compares a collaborative text editor built atop CScript with a state-of-the-art implementation. The results show that our approach is flexible and more memory efficient
Volatile Sets: Event-driven Collections for Mobile Ad-Hoc Applications
In mobile peer-to-peer applications, a common pattern is to maintain a collection of remotely-hosted objects. Traditional approaches require programmers to manually track the connectivity state of these remote objects and add them or remove them from local collections on a per-object basis. Because this happens concurrently with the rest of the application code, it hinders the composability of such collections and leads to subtle and hard to find bugs. In this paper, we propose an abstraction called volatile sets that allows the contents of the set to be specified intensionally. Additionally, volatile sets offer an event-driven API that signals when remote objects appear, disappear or change. Finally, volatile sets can be easily and efficiently composed through traditional set operations. We show how volatile sets ease the development of a collaborative peer-to-peer drawing application
A Principled Approach Towards Debugging Communicating Event-loops
Since the multicore revolution, software systems are more and more inherently concurrent. Debugging such concurrent software systems is still hard, but in the recent years new tools and techniques are being proposed. For such novel debugging techniques, the main question is how to make sure that the proposed techniques are sufficiently expressive. In this paper, we explore a formal foundation that allows researchers to identify debugging techniques and assess how complete their features are in the context of message-passing concurrency. In particular, we describe a principled approach for defining the operational semantics of a debugger. Subsequently, we apply this technique to derive the operational semantics for a communicating event-loop debugger. We show that our technique scales for defining the semantics of a wide set of novel breakpoints recently proposed by systems such as REME-D and Kómpos. To the best of our knowledge, this is the first formal semantics for debugging asynchronous message passing-based concurrency models
Multiverse Debugging: Non-deterministic Debugging for Non-deterministic Programs
Many of today's software systems are parallel or concurrent. With the rise of Node.js and more generally event-loop architectures, many systems need to handle concurrency. However, its non-deterministic behavior makes it hard to reproduce bugs. Today's interactive debuggers unfortunately do not support developers in debugging non-deterministic issues. They only allow us to explore a single execution path. Therefore, some bugs may never be reproduced in the debugging session, because the right conditions are not triggered. As a solution, we propose multiverse debugging, a new approach for debugging non-deterministic programs that allows developers to observe all possible execution paths of a parallel program and debug it interactively. We introduce the concepts of multiverse breakpoints and stepping, which can halt a program in different execution paths, i.e. universes. We apply multiverse debugging to AmbientTalk, an actor-based language, resulting in Voyager, a multiverse debugger implemented on top of the AmbientTalk operational semantics. We provide a proof of non-interference, i.e., we prove that observing the behavior of a program by the debugger does not affect the behavior of that program and vice versa. Multiverse debugging establishes the foundation for debugging non-deterministic programs interactively, which we believe can aid the development of parallel and concurrent systems
Collective Adaptive Systems: Qualitative and Quantitative Modelling and Analysis (Dagstuhl Seminar 14512)
This report documents the program and the outcomes of Dagstuhl Seminar 14512 "Collective Adaptive Systems: Qualitative and Quantitative Modelling and Analysis". Besides presentations on current work in the area, the seminar focused on the following topics:
(i) Modelling techniques and languages for collective adaptive systems based on the above formalisms. (ii) Verification of collective adaptive systems. (iii) Humans-in-the-loop in collective adaptive systems
MRD codes with maximum idealizers
Left and right idealizers are important invariants of linear rank-distance
codes. In the case of maximum rank-distance (MRD for short) codes in
the idealizers have been proved to be isomorphic to
finite fields of size at most . Up to now, the only known MRD codes with
maximum left and right idealizers are generalized Gabidulin codes, which were
first constructed in 1978 by Delsarte and later generalized by Kshevetskiy and
Gabidulin in 2005. In this paper we classify MRD codes in
for with maximum left and right idealizers
and connect them to Moore-type matrices. Apart from generalized Gabidulin
codes, it turns out that there is a further family of rank-distance codes
providing MRD ones with maximum idealizers for , odd and for ,
. These codes are not equivalent to any previously known MRD
code. Moreover, we show that this family of rank-distance codes does not
provide any further examples for .Comment: Reviewers' comments implemented, we changed the titl